package service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import constant.Constant;
import dao.CourseTypeDao;
import entity.CourseType;
import exception.DataAccessException;
import exception.ServiceException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import service.CourseTypeService;

import javax.servlet.http.HttpServletRequest;
import java.util.*;

@Service
public class CourseTypeServiceImpl implements CourseTypeService {
    @Autowired
    CourseTypeDao courseTypeDao;

    @Override
    public PageInfo<CourseType> findAllCourseType(HttpServletRequest request) {
        Integer parentId = null;
        if (request.getParameter("parent_id") == "" || request.getParameter("parent_id") == null) {
            parentId = 0;
        } else {
            parentId = Integer.parseInt(request.getParameter("parent_id"));
        }
        if (request.getParameter("pageNo") != null && request.getParameter("pageNo")!="") {
            Integer pageNo = Integer.parseInt(request.getParameter("pageNo"));
            PageHelper.startPage(pageNo, Constant.PAGE_SIZE);
        }

        List<CourseType> list = courseTypeDao.selectCourseType(parentId);
        if (null == list) {
            throw new ServiceException("暂无数据");
        }
        return new PageInfo<CourseType>(list);
    }

//    查询所有三级标题
    @Override
    public List<CourseType> findAllCourseType() {
        List<CourseType> threeCourseTypes = new ArrayList<>();

        try {
//            查询全部非禁用信息
            List<CourseType> allCourseTypes = courseTypeDao.selectAllEnable(Constant.STATUS_ENABLE);
//            封装集合，避免没有数据的情况
            if (null == allCourseTypes) {
                return threeCourseTypes;
            }
            List<CourseType> courseTypes = helpFindCourseType(allCourseTypes, null);

//            提取可用的三级标题
            for (int i = 0; i < courseTypes.size(); i++) {
                Set<CourseType> secondTypes = courseTypes.get(i).getChildrens();
                for (CourseType three:secondTypes) {
                    threeCourseTypes.addAll(three.getChildrens());
                }
            }
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        return threeCourseTypes;
    }

    @Override
    public PageInfo<CourseType> findBackCourseType(HttpServletRequest request) {
        Integer pageNo = Integer.parseInt(request.getParameter("pageNo"));
        String parentId = request.getParameter("parent_id");
//        分页
        PageHelper.startPage(pageNo, Constant.PAGE_SIZE);
        List<CourseType> list = courseTypeDao.queryByParentId(parentId);
        return new PageInfo<CourseType>(list);
    }

    @Override
    public int addBackType(HttpServletRequest request) {
//        课程类别不能重复,根据typeName和parentId来判断重复，先不考虑状态
        String typeName = request.getParameter("type_name");
        String parentId = request.getParameter("parent_id");
        String status = request.getParameter("status");
//        判断去重
        int num = courseTypeDao.quChong(typeName, parentId);
        if (num > 0) {
            return -1;
        }
        int result = courseTypeDao.addBackType(typeName, parentId, status);
        return result;
    }

    @Override
    public String toggleStatus(HttpServletRequest request) {
        String id = request.getParameter("id");
        String status = request.getParameter("status");
        int num = courseTypeDao.toggleStatus(id, status);
        return ((num > 0) ? "修改成功" : "修改失败");
    }

    @Override
    public CourseType showBackName(String id) {
        CourseType courseType = courseTypeDao.queryById(id);
        return courseType;
    }

    @Override
    public String modifyBackName(String id, String typeName) {
        int flag = courseTypeDao.modifyBackName(id, typeName);
        return ((flag > 0) ? "修改成功" : "修改失败");
    }

    // 加载课程类型数据（三级）
    @Override
    public List<CourseType> findCourseType() throws ServiceException {
        List<CourseType> courseTypes = new ArrayList<>();

        try {
//            查询全部非禁用信息
            List<CourseType> allCourseTypes = courseTypeDao.selectAllEnable(Constant.STATUS_ENABLE);
//            封装集合，避免没有数据的情况
            if (null != allCourseTypes) {
                courseTypes = helpFindCourseType(allCourseTypes, null);
            }
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        return courseTypes;
    }

    // 根据parent_id查找所有二级标题
    @Override
    public List<CourseType> findsecondType(Integer parent_id) throws ServiceException {
        List<CourseType> courseTypes = new ArrayList<>();

        try {
//            查询全部非禁用信息
            List<CourseType> allCourseTypes = courseTypeDao.selectAllEnable(Constant.STATUS_ENABLE);
//            封装集合，避免没有数据的情况
            if (null != allCourseTypes) {
                courseTypes = helpFindCourseType(allCourseTypes, parent_id);
            }
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        return courseTypes;
    }


    private List<CourseType> helpFindCourseType(List<CourseType> allCourseTypes, Integer parentId) {
//        用于接收一级标题，parent_id=null(0)<id,CourseType>
        Map<Integer, CourseType> primaryTitle = new HashMap<>();
//        用于接收其他标题，<id,CourseType>
        Map<Integer, CourseType> otherTitle = new HashMap<>();
//        用于接收childrens，<parent_id,childrens>
        Map<Integer, Set<CourseType>> findChildrens = new HashMap<>();

        for (int i = 0; i < allCourseTypes.size(); i++) {
            CourseType courseType = allCourseTypes.get(i);
            Integer parent_id = courseType.getParent_id();

//            查询一级标题
            if (null == parent_id) {
                primaryTitle.put(courseType.getId(), courseType);
                continue;
            }

//            查询其他标题
            otherTitle.put(courseType.getId(), courseType);
//            用于封装childrens
            Set<CourseType> courseTypeList = new HashSet<>();
            if (null == findChildrens.get(parent_id)) {// 第一次添加
                courseTypeList.add(courseType);
                findChildrens.put(parent_id, courseTypeList);
                continue;
            }
            findChildrens.get(parent_id).add(courseType);
        }

//        将三级标题封装到对应二级标题中，并将二级标题封装成childrens
        Map<Integer, Set<CourseType>> primaryChildrens = new HashMap<>();
        Set<Integer> ids = otherTitle.keySet();
        for (Integer id : ids) {
            Set<CourseType> childrens = findChildrens.get(id);
            // 排除其他标题中的三级标题和被禁用的二级标题
            if (null == childrens) {
                continue;
            }
            otherTitle.get(id).setChildrens(childrens);

            // 用于封装childrens<parent_id,childrens>
            Set<CourseType> courseTypeList = new HashSet<>();
            CourseType courseType = otherTitle.get(id);
            Integer parent_id = courseType.getParent_id();
            if (null == primaryChildrens.get(parent_id)) {// 第一次添加
                courseTypeList.add(courseType);
                primaryChildrens.put(parent_id, courseTypeList);
                continue;
            }
            primaryChildrens.get(parent_id).add(courseType);
        }

//        将二级标题封装到对应一级标题中
        Set<Integer> primaryIds = primaryTitle.keySet();
        for (Integer id : primaryIds) {
            primaryTitle.get(id).setChildrens(primaryChildrens.get(id));
        }

        // 根据二级标题的父类id返回所有可用二级标题
        if (null != parentId) {
            if (null != primaryTitle.get(parentId)) {
                return new ArrayList<>(primaryTitle.get(parentId).getChildrens());
            }
        }
        return new ArrayList<>(primaryTitle.values());
    }
}
